Compiler switches: -$ (defaults are shown below)

  A8  Aligned record fields
  B-  Full boolean Evaluation
  C+  Evaluate assertions at runtime
  D+  Debug information
  E-  Unknown
  F-  Force far procedure calls on | off.
  G+  Use imported data references
  H+  Use long strings by default
  I+  I/O checking
  J-  Writeable structured consts
  K-  Use smart callbacks.
  L+  Local debug symbols
  M-  Runtime type info
  N+  Numeric coprocessor support and floating point types
  O+  Optimization
  P+  Open string params
  Q-  Integer overflow checking
  R-  Range checking
  S-  Generate stack-overflow checking code
  T-  Typed @ operator
  U-  Pentium(tm)-safe divide
  V+  Strict var-strings
  W-  Generate stack frames
  X+  Extended syntax
  Y+  Symbol reference info
  Z1  Minimum size of enum types


 -----------------------------------------------------------------------------

$A[+|-|1|2|4|8]
 Align data on word boundaries.
  The $A compiler directive determines whether Delphi aligns data, or whether
  it packs the data into the smallest space.
  Note: In older versions of Delphi, this option could be checked on or off.
  Choosing 1 is the equivalent of off and 8 is the equivalent of on.
  
  * En mode {$A1} ou {$A-}, les champs ne sont jamais aligns. Tous les
   enregistrements et structures classe sont packed.
  * En mode {$A2}, les champs des types enregistrement dclars sans le
   modificateur packed et les champs des structures classe sont aligns sur
   les frontires des mots.
  * En mode {$A4}, les champs des types enregistrement dclars sans le
   modificateur packed et les champs des structures classe sont aligns sur
   les frontires des doubles mots.
  * En mode {$A8} ou {$A+}, les champs des types enregistrement dclars sans
   le modificateur packed et les champs des structures classe sont aligns sur
   les frontires des quadruples mots.
  
  Quel que soit le mode de la directive $A, les variables et constantes
  types sont toujours alignes pour un accs optimal. En mode {$A8},
  l'excution est plus rapide.


$B[+|-]
 Short circuit boolean expression evaluation
  The $B compiler directive tells Delphi whether to continue a multi argument
  boolean expression evaluation when the result is known before evaluation
  completes. 


$C[+|-]
 Evaluate assertions at runtime
  La directive $C active ou dsactive la gnration de code pour les
  assertions dans un fichier source Delphi. {$C+} est la valeur par dfaut.
  Comme les assertions ne sont pas habituellement utilises au moment de la
  compilation des versions commercialises d'un produit, les directives de
  compilation dsactivant la gnration de code pour les assertions sont
  fournies. {$C-} dsactivera les assertions.


$D[+|-]
 Generate debugger information, on for Debug, off for Release.
  The $D compiler directive determines whether Delphi builds debug
  information for the application.
  By default, Delphi builds the information, which provides the line number
  when a program abnormally terminates.
  The overheads for keeping $D on are minimal.


$F[+|-]
 Force far procedure calls on | off.


$G[+|-]
  Use imported data references.
   A reference to a global variable in a different unit ordinarily requires
   an extra level of indirection in case the other unit resides in a separate
   packaqe. The theory is that disabling this directive eliminates this
   indirection. In practice, this directive has no effect. The compiler
   automatically determines whether the indirection is needed and compiles
   references to global variables accordingly.


$H[+|-]
 Treat string types as AnsiString or ShortString
  The $H compiler directive determines whether Delphi treats the string type
  as an AnsiString when on (default) or ShortString when off.
  The default recognises that the general use of string types is to hold data
  that is likely to be longer than 255 characters (ShortString capacity).

  L'tat {$H-} est surtout pratique pour utiliser du code crit pour des
  versions prcdentes de Delphi qui utilisaient par dfaut le type chane
  courte. Vous pouvez localement surcharger la signification des dfinitions
  des types chanes pour assurer la gnration de chanes courtes. Vous
  pouvez aussi changer les dclarations des types chanes courtes en
  string[255] ou ShortString, qui ne sont pas ambigus et sont indpendants
  du paramtre $H.


$I[+|-]
 IO errors generate exceptions.
  Controls whether exceptions are thrown when an IO error occurs.
  {$I+} default generates the EInOutError exception when an IO error occurs.
  {$I-} does not generate an exception. Instead, it is the responsiblity of
  the program to check the IO operation by using the IOResult routine.


$J[+|-]
 Writeable structured consts
  Enable this for backward compatibility with Delphi 1.0 on Windows. When
  enabled, the compiler allows assignments to typed constants. Corresponds
  to {$J}.
  
  La directive $J contrle si les constantes types peuvent tre modifies
  ou non. En mode {$J+}, les constantes types peuvent tre modifies et sont
  essentiellement des variables initialises. En mode {$J-}, les constantes
  types sont rellement constantes et toute tentative de modification d'une
  constante type provoque l'mission d'une erreur par le compilateur.

  Dans les premires versions de Delphi et de Borland Pascal, les constantes
  types pouvaient toujours tre modifies, ce qui correspond au mode {$J+}.
  L'ancien code source utilisant des constantes types affectables doit tre
  compil en mode {$J+}, mais pour les nouvelles applications, il est
  conseill d'initialiser les variables et de compiler votre code en
  mode {$J-}.


$K[+|-]
 Use smart callbacks.


$L[+|-]
 Generate local symbol information for debugging, on for Debug, off for Release.
  The $L compiler directive determines whether Delphi saves local symbols
  when building debug information for the application.
  By default, Delphi builds the routine, variable and line number
  information, but this can be dsiabled by setting $L off.
  The overheads for keeping $L on are minimal.


$M[+|-]
 Runtime type info
  La directive $M contrle la gnration d'informations de type accessibles
   l'excution (RTTI). Lorsqu'une classe est dclare en mode {$M+}, le
  compilateur gnre des informations de type pour les champs, les mthodes
  et les proprits dclares dans les sections published de cette classe.

  Une application utilise directement l'indicateur $M de compilation trs
  rarement, si ce n'est jamais.


$M[minStackSize, maxStackSize]
 Tailles d'allocation mmoire
  La directive $M spcifie les paramtres d'allocation mmoire d'une pile
  d'application. 'minStackSize' doit tre un entier compris entre 1024 et
  2147483647, et spcifie la taille minimum d'une pile d'application.
  maxStackSize doit tre un entier compris entre 'minStackSize' et
  2147483647 spcifiant la taille maximum d'une pile d'application.

  S'il n'y a pas assez de mmoire disponible pour satisfaire les besoins
  minimum de pile d'une application, Windows mettra une erreur lors du
  dmarrage de l'application.
  Une pile d'application ne peut jamais dpasser la taille de pile maximum.
  Une telle tentative provoque une exception EStackOverflow.


$N[+|-]
 Numeric coprocessor support and floating point types : Single, Double,
  Extended, and Comp.


$O[+|-]
 Optimization
  The $O compiler directive determines whether Delphi compiles the current
  application with code optimization. Code optimization makes for slightly
  more efficient code operation, and size.

  Delphi does this in a way that preserves the logical integrity of the code,
  but which can confuse during debugging. This is especially true when Delphi
  creates no code for what it sees as redundant lines, such as variable
  assignment where the variable is then not used.


$P[+|-]
 Open String parameters
  Allow string variables of varying sizes to be passed to the same procedure
  or function. 
  
  La directive $P n'a de signification que pour du code compil en mode {$H-}
  et assure une compatibilit descendante avec les premires versions de
  Delphi et de Borland Pascal. $P contrle la signification des paramtres
  variables dclars en utilisant le mot rserv string en tant  l'tat
  {$H-}.

  * En mode {$P-}, les paramtres variables dclars  l'aide du mot cl
   string sont des paramtres variables normaux.
  * En mode {$P+} il s'agit de paramtres chanes ouverts.

  Quel que soit le positionnement de la directive $P, il est toujours possible
  d'utiliser l'identificateur openstring pour dclarer des paramtres chanes
  ouverts.


$Q[+|-]
 Integer overflow checking
  The $Q compiler directive determines whether Delphi should add code to
  check for integer and enum operation value overflows.
  This is set off by default, meaning that a bad integer or enum operation
  will pass unnoticed, revealing itself in a difficult to debug part of the
  code.
  It is recommended to switch on OverFlowChecks in order to detect overflows
  before they cause problems. This will result in the raising of an exception,
  allowing code testing to correctlt identify the point of failure.


$R[+|-]
 Range checking
  This is set off (-) by default, meaning that a bad array access will pass
  unnoticed, revealing itself in a difficult to debug part of the code.
  It is recommended to switch on $R in order to detect array bound problems.
  This will result in the raising of an exception, allowing code testing to
  correctlt identify the point of failure.


$S[+|-]
 Generate stack-overflow checking code.


$T[+|-]
 Typed @ operator
  Type checking of pointer value the @ operator returns when applied to a
  variable reference.


$U[+|-]
 Pentium(tm)-safe divide
  Generates Delphi code that detects a faulty floating-point division
  instruction.


$V[+|-]
 Strict var-strings.
  type-checking on strings passed as variable parameters


$W[+|-]
 Generate stack frames
  Generates special prolog and epilog code for far procedures and functions
  (stack frames), on for Debug off for Release.


$X[+|-]
 Extended syntax
  Enables you to define a function call as a procedure and to ignore the
  function result. Also enables PChar support.
  
  * Treating functions as procedures
   When +, Delphi will allow a function result to be ignored - unassigned -
   thereby treating the function as if it were a procedure.
 
  * Using Result in functions
   With $X-, you must return a function value by assigning to the pseudo
   variable of the same name as the function. For example :
    function GetValue : Integer; begin   GetValue := 23; end;
 
   With $X+, you can also assign to the pseudo variable 'Result'.
 
  * Treating Char arrays as strings
   With $X+, a zero base array of Char variables can be assigned a string
   value. It can also be assigned from, as long as the array has a #0 value
   element to signify the string end.


$Y[+|-]
 Symbol reference info
  Controls generation of symbol reference information for debugging purposes,
  on for Debug off for Release. 

  La directive $Y contrle la gnration des informations de rfrence aux
  symboles utiliss par l'explorateur de projet, l'explorateur de code et
  l'diteur de code. Ces informations sont prsentes sous la forme de
  tableaux donnant les numros des lignes du code source de toutes les
  dclarations et rfrences (dans l'tat {$Y+} aux identificateurs d'un
  module. Pour les units, ces informations sont mmorises dans le fichier
  '.dcu' avec le code objet de l'unit.
  
  Elles augmentent ainsi la taille des fichiers .dcu, mais cela n'affecte ni
  la taille, ni la vitesse d'excution du programme excutable.

  Lorsqu'un programme ou une unit est compil en mode par dfaut {$YD}, le
  compilateur enregistre les informations qui indiquent o est dfini chaque
  identificateur. Pour la plupart des identificateurs  variables, constantes,
  classes, etc.  le compilateur enregistre l'emplacement de la dclaration.
  Pour les procdures, fonctions et mthodes, il enregistre l'emplacement de
  l'implmentation. Cela active l'examen de l'diteur de code.

  * Lorsqu'un programme ou une unit est compil en mode {$Y+}, le compilateur
   enregistre les informations qui indiquent o est utilis chaque
   identificateur et o il est dfini. Cela active la page Rfrences de
   l'explorateur de projet.
  * Lorsqu'un programme ou une unit est compil en mode {$Y-}, aucune
   information de rfrence de symbole n'est enregistre. Cela dsactive
   l'examen de l'diteur de code et la page Rfrences de l'explorateur de
   projet.

  La bascule $Y est gnralement utilise en combinaison avec les bascules $D
  et $L, qui contrlent la gnration des informations de dbogage et de
  symboles locaux. La directive $Y n'a un effet que si $D et $L sont toutes
  deux actives.

  Remarque: La gnration des informations de rfrence croise compltes
  {$Y+} peut ralentir le cycle compilation/liaison, c'est pourquoi il vaut
  mieux ne pas l'utiliser, sauf quand vous avez besoin de la page Rfrences
  de l'explorateur de projet.


$Z[1|2|4]
 Sets the minimum storage used to hold enumerated types.
  The $Z compiler directive sets the minimum storage size, in bytes, that
  enumerated types will take.

  This is set to 1 byte by default, thereby providing capacity for 256
  enumerations. If you exceed the current storage size, by either defining
  rather a lot of enumeration values (over 256), or, more likely, defining
  enumeration values exceeding 256, then a larger storage size is used.
  The $Z directive simply defines the minimum number of bytes to use.

  Les modes {$Z2} et {$Z4} sont intressants pour l'interfaage avec des
  bibliothques C et C++, qui reprsentent habituellement des types numrs
  sous la forme de mots ou de doubles mots.

  Remarque: Les directives {$Z-} et {$Z+} sont aussi supportes pour une
  compatibilit descendante avec les premires versions de Delphi et de
  Borland Pascal. Elles correspondent respectivement  {$Z1} et {$Z4}.

